#!/usr/bin/env python3
import pyperf
import time


def func():
    time.sleep(0.001)


runner = pyperf.Runner()
runner.bench_func('sleep', func)

#!/usr/bin/env python3
import pyperf

runner = pyperf.Runner()
runner.timeit("sorted(list(range(1000)), key=lambda x: x)",
              stmt="sorted(s, key=f)",
              setup="f = lambda x: x; s = list(range(1000))")

#!/usr/bin/env python3
import sys
import pyperf

runner = pyperf.Runner()
runner.bench_command('python_startup', [sys.executable, '-c', 'pass'])

#!/usr/bin/env python3
import pyperf


def bench_dict(loops, mydict):
    range_it = range(loops)
    t0 = pyperf.perf_counter()

    for loops in range_it:
        mydict['0']
        mydict['100']
        mydict['200']
        mydict['300']
        mydict['400']
        mydict['500']
        mydict['600']
        mydict['700']
        mydict['800']
        mydict['900']

    return pyperf.perf_counter() - t0


runner = pyperf.Runner()
mydict = {str(k): k for k in range(1000)}
# inner-loops: dict[str] is duplicated 10 times
runner.bench_time_func('dict[str]', bench_dict, mydict, inner_loops=10)

# @Time    : 2021/12/26 22:43 
# @Author  : CharlieZhao
# @File    : test_multiprocessing.py
# @Software: PyCharm
# @Note    : This module is used to test performance of multiprocessing

""" To avoid performance deficiency caused by GIL, multiprocessing is a better way to 
perform concurrent tasks than threading. This module is used to test performance between 
multiprocessing and threading.
"""
 
from multiprocessing import Process
from threading import Thread
import time
 
 
def _print_number(info):
    res = 0
    for i in range(100_000_000):
        res = res + i
    print(info + " task over, result = {}".format(res))
 
 
def show_execution_time(start_time, end_time):
    print("The execution time is {} s".format(end_time - start_time))
 
 
def execute_multiprocessing_task():
    """
    log the execution time of multiprocessing task.
    :return: void
    """
    print(" multiprocessing task start ")
    p1 = Process(target=_print_number, args=("Process 1",))
    p2 = Process(target=_print_number, args=("Process 2",))
 
    start = time.time()
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    end = time.time()
 
    show_execution_time(start, end)
    print(" multiprocessing task end ")
 
 
def execute_threading_task():
    print(" threading task start ")
    t1 = Thread(target=_print_number, args=("Thread 1",))
    t2 = Thread(target=_print_number, args=("Thread 2",))
 
    start = time.time()
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    end = time.time()
 
    show_execution_time(start, end)
    print(" threading task end ")
 
 
if __name__ == "__main__":
    execute_multiprocessing_task()
    execute_threading_task()
    pass
 
"""
result:
 
 multiprocessing task start 
Process 2 task over, result = 4999999950000000
Process 1 task over, result = 4999999950000000
The execution time is 10.988635778427124 s
 multiprocessing task end 
 
 threading task start 
Thread 1 task over, result = 4999999950000000
Thread 2 task over, result = 4999999950000000
The execution time is 19.204389572143555 s
 threading task end 
 
可以很直观的看到在执行两个CPU密集型的独立任务时，使用多进程相较于使用多线程效率快了一倍以上。
当然，Python多线程也不是一无是处，在执行IO密集型任务时，单单使用多进程就不太适合了。
使用多进程+多线程的模式可以绕过阻塞线程，同时相较于单进程+多线程一定程度上减少了CPU线程切换的性能损失。
"""

# @Time    : 2021/12/29 22:41 
# @Author  : CharlieZhao
# @File    : test_asyncio.py 
# @Software: PyCharm

"""async task example"""

import threading
import asyncio
import time


def show_execution_time(start_time, end_time):
    print("The execution time is {} s".format(end_time - start_time))


async def _async_print_number(info):
    res = 0
    for i in range(100_000_000):
        res = res + i
        # 增加一条线程打印语句观测调用过程
        print(info, " res={} in {}".format(res, threading.currentThread()))
        await asyncio.sleep(1)  # 1s sleep 模拟IO等待,在等待时自动切换任务
    print(info + " task over, result = {}".format(res))


def execute_async_task():
    loop = asyncio.get_event_loop()
    # 创建两个任务
    tasks = [_async_print_number("async task 1:"), _async_print_number("async task 2:")]
    print(" async task start ")

    start = time.time()
    loop.run_until_complete(asyncio.wait(tasks))
    end = time.time()

    show_execution_time(start, end)
    print(" async task end ")


if __name__ == "__main__":
    execute_async_task()

"""
result: 可以看到两个任务1s为周期交替执行(实质是一个任务进入IO阻塞后，通过我们的协程调度逻辑，
在Event_loop中切换至另一个可用任务),且两个任务都在主线程中执行没有线程的切换。
async task start 
async task 2:  res=0 in <_MainThread(MainThread, started 21168)>
async task 1:  res=0 in <_MainThread(MainThread, started 21168)>
async task 2:  res=1 in <_MainThread(MainThread, started 21168)>
async task 1:  res=1 in <_MainThread(MainThread, started 21168)>
async task 2:  res=3 in <_MainThread(MainThread, started 21168)>
async task 1:  res=3 in <_MainThread(MainThread, started 21168)>
async task 2:  res=6 in <_MainThread(MainThread, started 21168)>
async task 1:  res=6 in <_MainThread(MainThread, started 21168)>
async task 2:  res=10 in <_MainThread(MainThread, started 21168)>
async task 1:  res=10 in <_MainThread(MainThread, started 21168)>
async task 2:  res=15 in <_MainThread(MainThread, started 21168)>
async task 1:  res=15 in <_MainThread(MainThread, started 21168)>
"""